// bzoj2258
//
// 题意：给定一个序列，可以插入一个字符，询问原始串中两个位置字符在新串
//       中后缀的lcp。插入操作最多200次。
//
// 题解：good。两个后缀的lcp让人想到后缀数组，关键是有插入。不过由于题目
//       只询问原串的字符，所以可以这样做。假设当前询问(l, r)，
//       看下l，r右边分别离l，r最近的插入的字符位置，分别记做lenl, lenr。
//       假设(l, r)的lcp len小于min(lenl, lenr)，那么答案就是len，
//       否则答案至少是min(lenl, lenr), 然后比较插入字符，再类似处理
//       (l', r')的lcp不断累加到答案里去。这样只需要求一次sa，
//       复杂度是O(nlogn + I * Q)。
//       下面有个注释的地方，如果直接用注释里的也能过，题目数据太弱，
//       但事实上不对，过不了
//
//       CCEEB
//       4
//       I E 5
//       I C 6
//       I E 6
//       Q 3 4
//
//       因为在比较插入字符的时候，原来不是插入字符的字符可能因为往后移动变成插入字符。
//
// run: $exec < bfdiff.in
// opt: 0
// flag: -g
//
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>

int const maxn = 51000;
char s[maxn];
int n;


int sa[maxn], height[maxn], rank[maxn], tmp_rank[maxn];
int gap;

bool suffix_cmp(int i, int j)
{
	if (rank[i] != rank[j]) return rank[i] < rank[j];
	return (i + gap < n && j + gap < n) ?
				(rank[i + gap] < rank[j + gap]) : (i > j);
}

void build_suffix_array()
{
	for (int i = 0; i < n; i++) { sa[i] = i; rank[i] = s[i]; }
	for (gap = 1; ; gap *= 2) {
		std::sort(sa, sa + n, suffix_cmp);
		for (int i = 0; i < n - 1; i++)
			tmp_rank[i + 1] = tmp_rank[i] + suffix_cmp(sa[i], sa[i + 1]);
		for (int i = 0; i < n; i++) rank[sa[i]] = tmp_rank[i];
		if (tmp_rank[n - 1] == n - 1) break;
	}
}

void build_lcp()
{
	for (int i = 0, k = 0; i < n; i++)
		if (rank[i] != n - 1) {
			for (int j = sa[rank[i] + 1]; s[i + k] == s[j + k]; k++);
			height[rank[i]] = k;
			if (k) k--;
		}
}


int st[maxn][17];

int log2(int x)
{
//	return std::log(x) / std::log(2);
	int ret = 0;
	for (; (1 << ret) <= x; ret++);
	return ret - 1;
}

void st_init(int data[])
{
	int len = log2(n);
	for (int i = 0; i < n; i++) st[i][0] = i;
	for (int l = 1; l <= len; l++)
		for (int i = 0; (i + (1<<l) - 1) < n; i++)
			if (data[ st[i][l - 1] ] < data[ st[i + (1<<(l-1))][l - 1] ])
				st[i][l] = st[i][l - 1];
			else
				st[i][l] = st[i + (1<<(l-1))][l - 1];
}

int query_interval_index(int const data[], int l, int r)
{
	int k = log2(r - l + 1);
	if (data[ st[l][k] ] < data[ st[r - (1<<k) + 1][k] ])
		return st[l][k];
	else
		return st[r - (1<<k) + 1][k];
}

int query_interval(int const data[], int l, int r)
{
	int tl = rank[l], tr = rank[r];
	if (tl > tr) std::swap(tl, tr);
	return data[ query_interval_index(data, tl, tr - 1) ];
}


struct ins_op { char ch; int pos; };

ins_op ins[500];
int len; // insert operations

void insert(int p, char ch)
{
	int i;
	for (i = 0; i < len; i++)
		if (ins[i].pos >= p) break;
		else				 p--;

	if (p > n) p = n;

	int ip = i;
	for (int i = len++; i > ip; i--)
		ins[i] = ins[i - 1];

	ins[ip].ch = ch;  ins[ip].pos = p;
}

int query(int l, int r)
{
	int nl, nr;
	for (nl = 0; ins[nl].pos <= l; nl++);
	for (nr = 0; ins[nr].pos <= r; nr++);
	if (l == r) return n - l + len - nl - 1;

	int ret = 0;
	for (; ; ) {
		int lenl = ins[nl].pos - l;
		int lenr = ins[nr].pos - r;
		int len = query_interval(height, l, r);
		int tmp = std::min(len, std::min(lenl, lenr));
		ret += tmp; l += tmp;  r += tmp;
		if (tmp == lenl || tmp == lenr) {
			for (; !(ins[nl].pos != l && ins[nr].pos != r); ) {
				for (; ins[nl].pos == l && ins[nr].pos == r; nl++, nr++)
					if (ins[nl].ch == ins[nr].ch) ret++;
					else						  return ret;
				for (; ins[nl].pos == l && ins[nr].pos != r; nl++, r++)
					if (ins[nl].ch == (int)s[r]) ret++;
					else						 return ret;
				for (; ins[nr].pos == r && ins[nl].pos != l; nr++, l++)
					if (ins[nr].ch == (int)s[l]) ret++;
					else						 return ret;
			}
			/*
			for (; ins[nl].pos == l && ins[nr].pos == r; )
				if (ins[nl].ch == ins[nr].ch) ret++, nl++, nr++;
				else						  return ret;
			for (; ins[nl].pos == l; )
				if (ins[nl].ch == s[r]) ret++, nl++, r++;
				else					return ret;
			for (; ins[nr].pos == r; )
				if (ins[nr].ch == s[l]) ret++, nr++, l++;
				else					return ret;
			*/
		} else return ret;
	}
	return ret;
}

int main()
{
	std::scanf("%s", s);
	n = std::strlen(s);
	build_suffix_array();
	build_lcp();
	st_init(height);

	ins[0].ch = 0;
	ins[0].pos = n;
	len = 1;

	int m;
	std::scanf("%d", &m);
	char ch[4];
	for (int i = 0; i < m; i++) {
		std::scanf("%s", ch);
		if (ch[0] == 'I') {
			int p;
			std::scanf("%s %d", ch, &p);
			insert(--p, ch[0]);
		} else {
			int x, y;
			std::scanf("%d %d", &x, &y);
			std::printf("%d\n", query(--x, --y));
		}
	}
}

